对逆向V9甚至V10真的很有帮助
原帖地址 [http://www.amobbs.com/forum.php?mod=viewthread&tid=5653964]

首先是个最简单的办法，不用拆机，没有风险，原理很简单，很多年前论坛上的大牛就发现并公布了这个办法，不过据说后来论坛浮云过一回，资料丢了。这个办法利用的是jlink自带的一个命令，这个命令能读取jlink自身的内存，我们只是需要用这个命令把bootloader部分的内容读取出来就可以了。

在进入这个具体命令之前，我们来看一下jlink的操纵方法，比较普遍的做法是调用jlinkarm.dll公开的接口，再有sdk的情况下，调用这些接口并不麻烦，但是如果没有sdk的话，c/c++语言要调用这些接口显得特别的麻烦，所以这里我们使用更为底层的办法越过jlink的dll，直接和jlink的驱动打交道。

首先，我们需要找到系统里面的jlink这个设备.

GUID classGuid = {0x54654E76, 0xdcf7, 0x4a7f, 0x87, 0x8A, 0x4E, 0x8F, 0x0CA, 0x0A, 0x0CC, 0x9A};
auto devInfoSet = SetupDiGetClassDevsW(&classGuid, nullptr, nullptr, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);

用上面的代码先找到jlink的class然后我们需要枚举这个devInfoSet里面的全部成员，依次取得各种信息，最终拿到jlink驱动提供的设备路径

SP_DEVICE_INTERFACE_DATA interfaceData = {0};
interfaceData.cbSize = sizeof(interfaceData);
for(DWORD i = 0; ; i ++)
{
    if(!SetupDiEnumDeviceInterfaces(devInfoSet, nullptr, &classGuid, i, &interfaceData))
        break;

    DWORD requiredSize = 0;
    SetupDiGetDeviceInterfaceDetailW(devInfoSet, &interfaceData, nullptr, 0, &requiredSize, nullptr);
    void* tempBuffer = new uint8_t[requiredSize];
    PSP_DEVICE_INTERFACE_DETAIL_DATA interfaceDetailData = static_cast<PSP_DEVICE_INTERFACE_DETAIL_DATA>(tempBuffer);
    interfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
    if(!SetupDiGetDeviceInterfaceDetailW(devInfoSet, &interfaceData, interfaceDetailData, requiredSize, &requiredSize, nullptr))
        continue;

到了这里interfaceDetailData->DevicePath这个里面就是jlink的设备路径，我们打开它

    HANDLE deviceFile = CreateFileW(interfaceDetailData->DevicePath, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
    if(deviceFile == INVALID_HANDLE_VALUE)
        continue;

这个打开的文件句柄主要是给jlink发送一些控制命令，真正读写的是需要打开另外两个句柄的，pipe00用来读，pipe01用来写，我们也打开它们

    wchar_t pipeFileName[1024] = {0};
    wcscpy_s(pipeFileName, interfaceDetailData->DevicePath);
    wcscat_s(pipeFileName, L"\\pipe00");
    HANDLE readPileFile = CreateFileW(pipeFileName, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
    if(readPileFile == INVALID_HANDLE_VALUE)
        continue;
    wcscpy_s(pipeFileName, interfaceDetailData->DevicePath);
    wcscat_s(pipeFileName, L"\\pipe01")；
    HANDLE writePileFile = CreateFileW(pipeFileName, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
    if(writePileFile == INVALID_HANDLE_VALUE)
        continue;

到了这里我们拿到了三个句柄，接下来我们就可以用这三个句柄来操控jlink了

首先介绍一下jlink的各种协议，这个协议有一部分公开了在它官网上，还有一个部分没有公开，大家可以去官网看看那个公开的文档，这里简单介绍一下。jlink的协议比较简单，当我们需要做某件事情的时候，就往jlink发送一个命令过去，jlink解析我们发送的命令，处理，并返回一个结果（也有许多命令不返回结果）我们发送给jlink的命令通过WriteFile函数调用写入到pipe01里面，然后通过读取pipe00获得命令结果。jlink的数据使用stream的模式读写，在满足一定的延时要求的情况下，我们可以将一个命令分成几截写入，也可以按批次读取结果，下面我们就用一个简单的命令来举个例子。这个命令用来获取jlink的固件版本，是一个公开的命令。首先我们发送单字节的01到jlinkjlink会返回0x72个字节的内容给我们，前面两个字节是le格式的长度=0x70，表示这之后还要0x70个字节，这0x70个字节就是真正的内容。

bool jlinkCommandReadFirmwareVersion(HANDLE readPipeFile, HANDLE writePipeFile, void* dataBuffer)
{
            uint8_t commandBuffer[1] = {0x01};
            uint16_t leftLength = 0;
            if(!jlinkSendCommand(readPipeFile, writePipeFile, commandBuffer, sizeof(commandBuffer), &leftLength, sizeof(leftLength)))
                        return false;
            return jlinkContinueReadResult(readPipeFile, dataBuffer, leftLength);
}

这里使用了两个函数，这两个函数下面会介绍，先看看这个函数的内容。首先我们调用jlinkSendCommand发送1个字节的0x01给jlink，并读回两个字节的内容，这两个字节的内容=0x70，也就是剩余的数据大小，然后我们调用jlinkContinueReadResult把剩下的内容读全了。注意，上面说过jlink使用的是stream模式，这就意味着，如果我没有未读完的数据还在jlink的缓冲区里面，那么这些内容会出现在下一条命令的返回结果里面，这里要特别小心。

bool jlinkSendCommand(HANDLE readPipeFile, HANDLE writePipeFile, void const* commandBuffer, uint32_t commandLength, void* resultBuffer, uint32_t resultHeaderLength)
{
     if(!WriteFile(writePipeFile, commandBuffer, commandLength, nullptr, nullptr))
        return false;
    if(!resultHeaderLength)
        return true;
        return !!ReadFile(readPipeFile, resultBuffer, resultHeaderLength, nullptr, nullptr);
}

bool jlinkContinueReadResult(HANDLE readPipeFile, void* resultBuffer, uint32_t resultLength)
{
        return !!ReadFile(readPipeFile, resultBuffer, resultLength, nullptr, nullptr);
}

这两个函数非常简单，一目了然。

有了这些辅助函数，我们来看下一个命令。

bool jlinkCommandReadEmulatorMemory(HANDLE readPipeFile, HANDLE writePipeFile, uint32_t address, uint32_t length, void* dataBuffer)
{
    uint8_t commandBuffer[9] =
    {
         0xfe,
         static_cast<uint8_t>(address), static_cast<uint8_t>(address >> 8), static_cast<uint8_t>(address >> 16), static_cast<uint8_t>(address >> 24),
         static_cast<uint8_t>(length), static_cast<uint8_t>(length >> 8), static_cast<uint8_t>(length >> 16), static_cast<uint8_t>(length >> 24),
    };

    return jlinkSendCommand(readPipeFile, writePipeFile, commandBuffer, sizeof(commandBuffer), dataBuffer, length);
}

这就是关键命令了，id=0xfe，读取jlink自身的内存区域，命令id之后是4个字节的地址，然后是4个字节的长度，都是le格式。在使用这个命令的时候要注意，jlink有缓冲区大小限制，我们不能一次发送太多的数据到jlink，我们也不能一次读取太多的数据，这个缓冲区限制大小是64k，我们也可以使用下面两个函数获取这个值。

uint32_t jlinkGetReadBufferSize(HANDLE deviceFile)
{
            uint32_t readBufferSize = 0;
            jlinkDeviceControl(deviceFile, 0x220460, nullptr, 0, &readBufferSize, sizeof(readBufferSize));
            return readBufferSize;
}

uint32_t jlinkGetWriteBufferSize(HANDLE deviceFile)
{
            uint32_t writeBufferSize = 0;
            jlinkDeviceControl(deviceFile, 0x220464, nullptr, 0, &writeBufferSize, sizeof(writeBufferSize));
            return writeBufferSize;
}

而jlinkDeviceControl这个函数只是一个简单的封装

bool jlinkDeviceControl(HANDLE deviceFile, uint32_t controlCode, void* inputBuffer, uint32_t inputSize, void* outputBuffer, uint32_t outputSize, uint32_t* actualSize = nullptr)
{
            DWORD resultSize = 0;
            if(!DeviceIoControl(deviceFile, controlCode, inputBuffer, sizeof(inputSize), outputBuffer, sizeof(outputSize), &resultSize, nullptr))
                        return false;

            if(actualSize)
                        *actualSize = static_cast<uint32_t>(resultSize);
            return true;
}

函数都全了，接下来就进入主题了。首先我们知道jlink的bootloader占用的是0x08000000到0x08010000之间的64k内容，其中从0x0800b700开始到0x0800c000的部分占据0x900个字节，jlink管他称为ots，大概是什么one time section的缩写？这部分放的大约有3个东西，序列号，license，然后还有一段签名，这个贴的最后有部分ots的介绍。这部分jlink并没有提供擦出功能，只能写入，你只能把某个位从1变成0，不能反过来（所以才叫one time？）然后是从0x0800c000开始到0x0800c900同样也是0x900个字节的内容，这个部分jlink管他叫config data，这部分jlink能够擦出，并且能用jlink自带的jlinkconfig.exe修改。他里面主要放的是一些配置信息，比如昵称，是否打开虚拟串口，是否使用jlink给目标板供电什么的。
我们在读取bootloader的时候完全可以跳过ots和config部分，读取前面的0xb700个字节就可以了（实际上bootloader只有不到0x4000个字节）

    uint8_t bootloader[0xb700] = {0};
    jlinkCommandReadEmulatorMemory(readPipeFile, writePipeFile, 0x08000000, sizeof(bootloader), bootloader);

就是这么简单，我们就拿到了bootloader。

但是不要着急，我们跳过了ots和config，这两个部分也挺重要的。如果我们只是希望把挂掉的jlink救活，并且我们的jlink本身就是正版（正版会丢固件吗？我有个盗版丢了），那我们也需要把ots也读出来，但是不要把ots发给其他人，ots里面有唯一的设备签名。把坏掉的jlink擦除掉，然后把这个bootloader刷回去，通电，jlink能识别这个设备，即使这个设备里面只有bootloader，jlink会显示出bootloader的版本来。大约是“J-Link V9 compiled Oct 12 2012 BTL”这样的。然后我们可以使用jlinkconfig.exe从新写入固件，并不需要自己手动去jlink的dll里面导出固件再手动往里面刷。
如果我们想做个一摸一样的复制品（序列号也原样复制），那也把ots读出来。
如果我们想干坏事，批量生产一波，那么还需要了解一下ots这个东西。ots有两个部分，从0xb700开始的0x100字节是一段数字签名，很不幸我这盗版jlink里面全是ff，正版用户可以看看这256个字节的数字签名。jlink使用的是salt长度为4的rsa-pss算法来生成这段签名的。至于rsa-pss算法大家可以google一下。签名的原始数据长度16个字节，前面4个字节是序列号，后面12个字节是stm32提供的设备唯一id。rsa算法长度2048，很不幸现在没啥希望能算出他的私钥，所以大部分（全部？）的盗版这个签名部分都是0xff吧。这段签名即使全是0xff也不影响jlink的功能，只是能用这个签名判断出是否是正版jlink，判断办法如下。

bool jlinkCommandVerifySignature(HANDLE readPipeFile, HANDLE writePipeFile)
{
            uint8_t commandBuffer[] =
            {
                        0x18,
                        0x01,
                        0x01, 0x00, 0x00, 0x00,
                        0x00, 
                        0x00,
            };

            int32_t isValid                                                                                                                = 0;
            if(!jlinkSendCommand(readPipeFile, writePipeFile, commandBuffer, sizeof(commandBuffer), &isValid, sizeof(isValid)))
                    return false;
            return isValid > 0;
}

这个函数返回true的时候，那签名就是合法的，否则就是非法的，我大致看了看jlink的dll，似乎并没有使用这个判断？签名这个0x100个字节我们先放一边（不放一边也没办法，2048位的rsa束手无策的）rsa的e是常客0x10001,n在下面

其实知道了也没啥用。

接下来我们来看看序列号，他位于bf00，这个序列号用的地方有两个，一个自然就是序列号，另外一个是硬件版本，是的你没有看错。硬件版本是用序列号来计算的，首先把序列号除以100000，得到的商再除以10，得到的余数如果大于等于8则取2，得到的就是子版本号。比如我这个盗版设备，sn=59101308，他的硬件版本显示为9.10sn先除以100000，商591，再除以10，余1，所以就是9.10当序列号这个位置4个字节都是ff的时候，我们可以使用exec setsn=xxx来设置一个序列号，如果序列号已经有值了，这个命令就不能用了。

然后就是license，他从bf20开始，每个license占16个字节，他们就是普通的ascii字符串，包括结尾的0。这个部分可以使用exec addfeature来添加license。
所以如果数字签名本身就是无效的话，那么ots部分我们可以完全不用管他，全部擦除成ff，然后用jlink的命令写入需要的值就可以了。当然jlink也提供了两个命令来更新ots，这里介绍一个简单的，他只是更新bf00开始的0x100个字节，这个区域里面包括序列号和license。

int32_t jlinkCommandWriteOneTimeSettings(HANDLE readPipeFile, HANDLE writePipeFile, void const* dataBuffer)
{
            uint8_t commandBuffer[0x10d] = {0x13};
            uint32_t tempValue = crc32(0xffffffff, static_cast<uint8_t const*>(dataBuffer), 0x100) ^ 0xffffffff;
            commandBuffer[0x101] = static_cast<uint8_t>(tempValue);
            commandBuffer[0x102] = static_cast<uint8_t>(tempValue >> 8);
            commandBuffer[0x103] = static_cast<uint8_t>(tempValue >> 16);
            commandBuffer[0x104] = static_cast<uint8_t>(tempValue >> 24);
            commandBuffer[0x105] = 0x49;
            commandBuffer[0x106] = 0x44;
            commandBuffer[0x107] = 0x53;
            commandBuffer[0x108] = 0x45;
            commandBuffer[0x109] = 0x47;
            commandBuffer[0x10a] = 0x47;
            commandBuffer[0x10b] = 0x45;
            commandBuffer[0x10c] = 0x52;
            memcpy(commandBuffer + 1, dataBuffer, 0x100);
            if(!jlinkSendCommand(readPipeFile, writePipeFile, commandBuffer, sizeof(commandBuffer), &tempValue, sizeof(tempValue)))
                    return -1;

            return static_cast<int32_t>(tempValue);
}

发送过去的命令长度0x10d，第一个字节是命令id=0x13,接下里0x100个字节就是新的ots数据，然后是4个字节的crc32（根据crc32实现的默认初始值不同，我们可能需要调整0xffffffff这个值为0），接下来8个字节是个常量，他等于IDSEGGER的ascii码。这个命令返回一个错误代码，如果成功写入了，返回的是0，否则返回一个负值。注意，这个ots并不是我们想改成什么样子就能改成什么样子的，我们发送过去的0x100字节的新数据必须满足三个条件。第一，如果原来的ots里面已经有一个非ffffffff的序列号了，那么我们的对应的序列号必须要和原始序列号相同，也就是说我们只有一次机会把序列号从0xffffffff改成其他的。第二，我们发送过去的0x100数据里面的license不能是空的，具体的说就是0x100的ots数据的偏移量0x20这个地方不能是0第三，我们只能把原始数据里面是1的位变成0，不能反过来。如果我们发送过去的数据不满足这三个条件，jlink都会返回错误。至于原来的bf00这部分的数据是什么，我们可以使用上面那个jlinkCommandReadEmulatorMemory函数来读取，或者可以使用下面这个专属命令。

 bool jlinkCommandReadOneTimeSettings(HANDLE readPipeFile, HANDLE writePipeFile, void* dataBuffer)
{
            uint8_t commandBuffer[1] = {0xe6};
            return jlinkSendCommand(readPipeFile, writePipeFile, commandBuffer, sizeof(commandBuffer), dataBuffer, 0x100);
}

这个命令他只能读取固定的0x100个字节的数据（bf00到c000）
当然也有进阶的读取和更新全部0x900数据的命令，但是用处不大（我们盗版用户也没办法生成新的数字签名），这里就不多介绍了，感兴趣的朋友可以自己逆向一下jink的固件当前版本的固件大约是这样的

接下来我们来看一个麻烦一点的办法，这个有风险要拆机，我的bootloader就是用这个办法弄出来的。这也是论坛上各位大牛早就研究过的办法，就是写一段木马进去把bootloader用串口的办法发送出来。这里我们使用一个相对安全的办法来dump出bootloader。我们在jlink的固件里面找到一段不使用代码，插入我们的一段小程序进去，然后把启动向量指向我们的小程序，这段小程序在上电的时候先通过读取某gpio管教的电平高低来决定继续执行还是跳转到原始jlink的启动向量。这样一来，我们的这段小程序不会影响到jlink本身的功能，jlink可以正常使用，只有在上电的时候我们短接某个管脚，才会进入dump模式。只要我们的程序在判读管脚高低电平的时候没有出错，即使接下里的代码里面有问题，也没关系，因为jlink是可以正常使用的，我们可以修改再来过。
因为我们的代码要和jlink的代码共存，所以，我们需要使用汇编语言来生成这段代码，这样能做到比较短小，毕竟jlink里面废代码并不多

首先我们需要找到“废代码”的位置，这个挺容易的，中断表里面通常有很多中断都是不使用的，对应的中断处理函数的代码都是一个死循环。我们可以直接覆盖掉这些中断处理函数，因为他们本身就不会被触发，为了安全我们可以保留一个这样的函数，并把其他的中断向量都指向到这个函数上，这里我偷懒并没有这样做。那么这段废代吗在什么地方呢?就在0802cff0的地方，我们可以看到这里都是一堆的jump指令，好了，覆盖他们

ldr                r0, =0x40023830
ldr                r1, [r0]
orr                r1, r1, #7
str                r1, [r0]                                // enable GPIOA, GPIOB, GPIOC

ldr                r5, =0x40020400
ldr                r0, [r5]
bic                r0, r0, #0xf00000
orr                r0, r0, #0x200000
str                r0, [r5]                                // PB10 = af, PB11 = input

add                r2, r5, #0x10                        // read PB11
ldr                r0, [r2]
tst                r0, #0x800                                // if PB11 is high then jmp to jlink
bne                finished

add                r4, r5, #0x24
ldr                r0, [r4]
bic                r0, r0, #0xf00
orr                r0, r0, #0x700                        // sete PB10 as af7 = USART3_TX
str                r0, [r4]

ldr                r0, =0x40023840                        // enable USART3 clock
ldr                r1, [r0]
orr                r1, r1, #0x40800                // enable USART3 + WWDG
str                r1, [r0]

ldr                r4, =0x40004800                        // r4 = USART_SR
add                r5, r4, 0x0c                        // r5 = USART_CR
ldr                r0, [r5]
bic                r0, #0x2000                                // UE = 0, disable USART first
str                r0, [r5]

mov                r0, #0x0008                                // TE = 1, enable tx
str                r0, [r5]
add                r3, r4, #0x10                        // r3 = USART_CR2
mov                r0, #0
str                r0, [r3]

add                r3, r4, #0x08                        // r3 = USART_BRR
mov                r0, #0x104                                // 30Mhz / 115200 / 16 = 16.25
str                r0, [r3]

ldr                r0, [r5]
orr                r0, #0x2000                                // UE = 1, enable USART
str                r0, [r5]

add                r5, r4, #4                                // r5 = USART_DR

ldr                r6, =0x40002c00                        // r6 = WWDG_CR
mov                r7, #0x7f

 dump_start:
ldr                r1, =0x08000000                        // r1 = current address
mov                r2, #0x10000                        // r2 = left count

wait_txe:
ldr                r0, [r4]
tst                r0, #0x80                                // test TXE
beq                wait_txe

str                r7, [r6]                                // reload watchdog
ldrb              r0, [r1], #1                        // load current byte and output to USART3
str                r0, [r5]

wait_tc:
ldr                r0, [r4]
tst                r0, #0x40                                // wait TC
beq                wait_tc

subs               r2, r2, 1
bne                wait_txe
b                   dump_start

finished:
ldr                pc, =0x0802cf61    // jump to jlink's reset handler

代码简单直接，就不多描述了，我是用的时arm-gcc编译器，大家也许需要做做移植工作才能在别的编译器下面编译。这里面也许唯一需要说的就是串口的波特率计算，怎么知道当前的时钟频率究竟是多少。当然也可以不管三七二十一初始化一趟RCC，不过这样会增加许多的代码量，我这里比较偷懒，首先假定时钟频率是16MHz，然后按照115200的波特率算出一个值来，接着让它开始dump，然后接入一个能自动分析波特率的逻辑分析仪，逻辑分析仪能汇报一个不太准确的波特率，没关系，用这个不太准确的波特率回推出一个不太准确的时钟频率，我这里算出来是个30.13MHz，那么显然实际的时钟就是30MHz然后在修改成30MHz的参数实际的跑一下，顺利拿到bootloader。

然后还有一个，这个固件里面的初始化数据经过压缩，也不知道是谁家的编译器（ti家的编译器有这个压缩功能，不过我没详细看过），大家还需要一份代码来解压缩。

uint8_t const* in8 = 0x0802D2BC；
uint8_t* out8 = 0x20000008;
while(out8 < 0x20000008 + 0x814)
{
    uint32_t c  = *in8 ++;
    uint32_t a = c & 3;
    if(!a)
        a = 3 + static_cast<uint32_t>(*in8 ++);

    uint32_t b = c >> 4;
    if(b == 0x0f)
        b = 0xf + static_cast<uint32_t>(*in8 ++);

    while(-- a)
        *out8 ++ = *in8 ++;

    if(b)
    {
        uint32_t e = *in8 ++;
        uint32_t d = (c >> 2) & 0x03;
        if(d == 3)
            d = *in8 ++;

        d = (d << 8) + e;
        uint8_t* back8 = out8 - d;
        for(uint32_t j = 0; j < b + 2; j ++)
            *out8 ++ = *back8 ++;
        }
    }

也很简单的，当前这个版本，压缩之前的代码在0802D2BC，长度0x668，解开到20000008，长度0x814解开的数据可以用ida再加载进去。方便分析。